home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Technology Seed / ADC Seed CD - July 1999.toast / ColorSync / ColorSync 2.6 Mac SDK / Sample Code / DemoCMM / DemoCMM.c next >
Encoding:
C/C++ Source or Header  |  1999-04-12  |  40.4 KB  |  1,494 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        DemoCMM.c
  3.  
  4.     Contains:    Demo CMM Component for ColorSync 2.x
  5.                 
  6.                 This is a very simple CMM - so simple in fact that the only thing
  7.                 it uses from a profile is its colorspace.
  8.                 
  9.                 If the first (source) profile is RGB and the last (dest) profile
  10.                 is CMYK, then this CMM uses the simple "one minus" formula
  11.                 to convert from from RGB to CMYK.
  12.                 
  13.                 If the first (source) profile is CMYK and the last (dest) profile
  14.                 is RGB, then this CMM uses the inverse of the "one minus" formula
  15.                 to convert from from CMYK to RGB.
  16.  
  17.                 If the first and the last profile are RGB or if the first and the 
  18.                 last profile are CMYK, then this CMM leaves the colors unchanged.
  19.                 
  20.     Version:    ColorSync 2 or later
  21.  
  22.     Written by:    David Hayward
  23.  
  24.     Copyright:    © 1998-1999 by Apple Computer, Inc., all rights reserved.
  25.  
  26.     Writers:
  27.         (DH)    David Hayward
  28.  
  29.     Change History (most recent first):
  30.  
  31.          <5>      2/1/99    DH        Added some CS2.6 features
  32.          <4>    10/20/98    DH        Fixed Win32 exports.
  33.          <2>    10/13/98    DH        Overhaul to build x-platform.
  34.          <1>     7/16/98    DH        First checked in.
  35.  
  36. */
  37.  
  38. #include <ConditionalMacros.h>
  39.  
  40. #if TARGET_OS_WIN32
  41.     #pragma warning (disable : 4068) // disable warnings for #pragma mark...
  42.     #if __MWERKS__
  43.         #include <x86_prefix.h>
  44.     #endif
  45.     #include <windows.h>
  46.     #undef  pascal
  47.     #define pascal
  48. #endif
  49.  
  50. #include <MacTypes.h>
  51. #include <Errors.h>
  52. #include <Endian.h>
  53. #include <MacMemory.h>
  54. #include <Gestalt.h>
  55. #include <Components.h>
  56. #include <CMMComponent.h>
  57.  
  58. #if TARGET_OS_MAC
  59. #include <math.h>
  60. #else
  61. #include <fp.h>
  62. #endif
  63.  
  64. #ifndef DEBUG
  65. #define DEBUG 0
  66. #endif
  67.  
  68. #define CMM_ENTRY        __declspec(dllexport) 
  69.  
  70. // Component version
  71. #define     kCMCodeVersion        1
  72. #define        kCMMVersion            ((CMMInterfaceVersion << 16) | kCMCodeVersion)
  73.  
  74. typedef void (*MatchOneProc) (UInt16* chan);
  75.  
  76.  
  77. // Component storage
  78. typedef struct
  79. {
  80.     ComponentInstance    ci;
  81.     OSType                srcSpace;
  82.     OSType                srcClass;
  83.     OSType                dstSpace;
  84.     OSType                dstClass;
  85.     MatchOneProc        proc;
  86. } CMMStorageRec, *CMMStoragePtr, **CMMStorageHdl;
  87. // Note that on Mac, CMMStorageHdl is a Handle
  88. // whereas on Win32, CMMStorageHdl is a ptr to a ptr
  89.  
  90.  
  91. // Match stuff
  92. typedef struct
  93. {
  94.     CMMStorageHdl        storage;
  95.     
  96.     UInt32                height;
  97.     UInt32                width;
  98.     
  99.     OSType                srcSpace;
  100.     UInt8*                srcBuf[4];
  101.     UInt32                srcChanBits;
  102.     UInt32                srcRowBytes;
  103.     UInt32                srcColBytes;
  104.     Boolean                srcSwap;
  105.     
  106.     OSType                dstSpace;
  107.     UInt8*                dstBuf[4];
  108.     UInt32                dstChanBits;
  109.     UInt32                dstRowBytes;
  110.     UInt32                dstColBytes;
  111.     Boolean                dstSwap;
  112.     
  113. } CMMMatchRec, *CMMMatchPtr, **CMMMatchHdl;
  114.  
  115.  
  116. // Technique for Native PPC Component function calls from Tech Note "QT05-Component Mgr 3.0"
  117. #if TARGET_CPU_PPC
  118.     #define CCFWS(storage,params,name)    CallComponentFunctionWithStorage(storage, params, &name##RD)
  119.     #define CCF(params,name)             CallComponentFunction(params, &name##RD)
  120.     #define INSTANTIATE_RD(name)        RoutineDescriptor name##RD = BUILD_ROUTINE_DESCRIPTOR(upp##name##ProcInfo, name)
  121. #else
  122.     #define CCFWS(storage,params,name)    CallComponentFunctionWithStorage(storage, params, (ComponentFunctionUPP)name)
  123.     #define CCF(params,name)            CallComponentFunction(params, (ComponentFunctionUPP)name)
  124. #endif
  125.  
  126.  
  127. // proc infos
  128. enum {
  129.     uppDoComponentOpenProcInfo = kPascalStackBased
  130.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  131.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(ComponentInstance))),
  132.     uppDoComponentCloseProcInfo = kPascalStackBased
  133.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  134.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Handle)))
  135.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(ComponentInstance))),
  136.     uppDoComponentCanDoProcInfo = kPascalStackBased
  137.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  138.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short))),
  139.     uppDoComponentVersionProcInfo = kPascalStackBased
  140.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))),
  141.     uppDoComponentRegisterProcInfo = kPascalStackBased
  142.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult))),
  143.     uppDoCMMInitProcInfo = kPascalStackBased
  144.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  145.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Handle)))
  146.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(CMProfileHandle)))
  147.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(CMProfileHandle))),
  148.     uppDoNCMMInitProcInfo = kPascalStackBased
  149.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  150.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Handle)))
  151.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(CMProfileRef)))
  152.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(CMProfileRef))),
  153.     uppDoCMMConcatInitProcInfo = kPascalStackBased
  154.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  155.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Handle)))
  156.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(CMConcatProfileSet*))),
  157.     uppDoNCMMConcatInitProcInfo = kPascalStackBased
  158.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  159.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Handle)))
  160.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(NCMConcatProfileSet*)))
  161.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(CMConcatCallBackUPP)))
  162.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*))),
  163.     uppDoCMMMatchColorsProcInfo = kPascalStackBased
  164.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  165.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Handle)))
  166.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(CMColor*)))
  167.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32))),
  168.     uppDoCMMCheckColorsProcInfo = kPascalStackBased
  169.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  170.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Handle)))
  171.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(CMColor*)))
  172.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32)))
  173.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(UInt32*))),
  174.     uppDoCMMMatchBitmapProcInfo = kPascalStackBased
  175.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  176.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Handle)))
  177.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(CMBitmap*)))
  178.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(CMBitmapCallBackUPP)))
  179.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
  180.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(CMBitmap*))),
  181.     uppDoCMMCheckBitmapProcInfo = kPascalStackBased
  182.          | RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
  183.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Handle)))
  184.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(CMBitmap*)))
  185.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(CMBitmapCallBackUPP)))
  186.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(void*)))
  187.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(CMBitmap*)))
  188. };
  189.  
  190.  
  191. // function prototypes
  192. #if TARGET_OS_MAC
  193. pascal ComponentResult main                            (ComponentParameters *params, Handle storage);
  194. static pascal ComponentResult DoComponentOpen        (ComponentInstance self);
  195. static pascal ComponentResult DoComponentClose        (CMMStorageHdl storage, ComponentInstance self);
  196. static pascal ComponentResult DoComponentCanDo        (short selector);
  197. static pascal ComponentResult DoComponentVersion    (void);
  198. static pascal ComponentResult DoComponentRegister    (void);
  199. #endif
  200. static pascal CMError DoCMMInit                (CMMStorageHdl storage, CMProfileHandle srcProfile, CMProfileHandle dstProfile);
  201. static pascal CMError DoNCMMInit            (CMMStorageHdl storage, CMProfileRef srcProfile, CMProfileRef dstProfile);
  202. static pascal CMError DoCMMConcatInit        (CMMStorageHdl storage, CMConcatProfileSet* profileSet);
  203. static pascal CMError DoNCMMConcatInit        (CMMStorageHdl storage, NCMConcatProfileSet* profileSet, CMConcatCallBackUPP proc, void* refCon);
  204. static pascal CMError DoCMMMatchColors        (CMMStorageHdl storage, CMColor *colorBuf, UInt32 count);
  205. static pascal CMError DoCMMCheckColors        (CMMStorageHdl storage, CMColor *colorBuf, UInt32 count, UInt32 *gamutResult);
  206. static pascal CMError DoCMMMatchBitmap        (CMMStorageHdl storage, const CMBitmap * srcMap, CMBitmapCallBackUPP progressProc, void* refCon, CMBitmap* dstMap);
  207. static pascal CMError DoCMMCheckBitmap        (CMMStorageHdl storage, const CMBitmap * srcMap, CMBitmapCallBackUPP progressProc, void* refCon, CMBitmap* chkMap);
  208. static CMError         CheckStorage            (CMMStorageHdl storage);
  209. static void            MatchAll                (CMMMatchPtr pMatchInfo);
  210. static void MatchOne_RGB_CMYK    (UInt16* chan);
  211. static void MatchOne_CMYK_RGB    (UInt16* chan);
  212. static void MatchOne_RGB_XYZ    (UInt16* chan);
  213. static void MatchOne_XYZ_RGB    (UInt16* chan);
  214. static void MatchOne_RGB_LAB    (UInt16* chan);
  215. static void MatchOne_LAB_RGB    (UInt16* chan);
  216. static void MatchOne_XYZ_LAB    (UInt16* chan);
  217. static void MatchOne_LAB_XYZ    (UInt16* chan);
  218. static void MatchOne_XYZ_Gray    (UInt16* chan);
  219. static void MatchOne_Gray_XYZ    (UInt16* chan);
  220. static void MatchOne_CMYK_LAB    (UInt16* chan);
  221. static void MatchOne_LAB_CMYK    (UInt16* chan);
  222. static void MatchOne_CMYK_XYZ    (UInt16* chan);
  223. static void MatchOne_XYZ_CMYK    (UInt16* chan);
  224. static void MatchOne_RGB_Gray    (UInt16* chan);
  225. static void MatchOne_Gray_RGB    (UInt16* chan);
  226. static void MatchOne_LAB_Gray    (UInt16* chan);
  227. static void MatchOne_Gray_LAB    (UInt16* chan);
  228. static void MatchOne_CMYK_Gray    (UInt16* chan);
  229. static void MatchOne_Gray_CMYK    (UInt16* chan);
  230.  
  231.  
  232. #if TARGET_OS_MAC
  233. // RoutineDescriptors
  234. #if TARGET_CPU_PPC
  235.     // RoutineDescriptors for Component functions
  236.     INSTANTIATE_RD(DoComponentOpen);
  237.     INSTANTIATE_RD(DoComponentClose);
  238.     INSTANTIATE_RD(DoComponentCanDo);
  239.     INSTANTIATE_RD(DoComponentVersion);
  240.     INSTANTIATE_RD(DoComponentRegister);
  241.     INSTANTIATE_RD(DoCMMInit);
  242.     INSTANTIATE_RD(DoNCMMInit);
  243.     INSTANTIATE_RD(DoCMMConcatInit);
  244.     INSTANTIATE_RD(DoNCMMConcatInit);
  245.     INSTANTIATE_RD(DoCMMMatchColors);
  246.     INSTANTIATE_RD(DoCMMCheckColors);
  247.     INSTANTIATE_RD(DoCMMMatchBitmap);
  248.     INSTANTIATE_RD(DoCMMCheckBitmap);
  249.  
  250.     // PowerPC main Component entry point
  251.     RoutineDescriptor mainRD = BUILD_ROUTINE_DESCRIPTOR(uppComponentRoutineProcInfo, main);
  252. //    ProcInfoType __procinfo = uppComponentRoutineProcInfo;
  253. #endif
  254.  
  255.  
  256. #if TARGET_CPU_68K
  257. #pragma code68020 off                        // this functions must run on all Macs
  258. #endif
  259.  
  260. #pragma mark -
  261. #pragma mark ————— Mac component entry point —————
  262.  
  263.  
  264. /* ______________________________________________________________________
  265.  
  266.     ComponentResult
  267.  
  268.     Abstract:
  269.         main entry point to CMM Component
  270.  
  271.     Params:
  272.         params        (in)    Parameters in form used by Component Manager
  273.         storage        (in)    Handle to memory to be used by CMM
  274.         
  275.     Return:
  276.         noErr        If successful
  277.                     Otherwise System or ColorSync result code
  278.  
  279.    _____________________________________________________________________ */
  280.  
  281.  
  282. pascal ComponentResult
  283. main (ComponentParameters *params, Handle storage)
  284. {
  285.     ComponentResult        result = noErr;        /* Init for error handling */
  286.     short                message;        
  287.  
  288.     message = (*params).what;
  289.  
  290.     /* Selectors < 0 for Component Manager functions */ 
  291.     if (message < 0)
  292.     {
  293.         switch (message)
  294.         {
  295.             case kComponentOpenSelect :
  296.             result = CCF(params, DoComponentOpen);
  297.             break;
  298.             
  299.             case kComponentCloseSelect :
  300.             result = CCFWS(storage, params, DoComponentClose);
  301.             break;
  302.             
  303.             case kComponentCanDoSelect :
  304.             result = CCF(params, DoComponentCanDo);
  305.             break;
  306.             
  307.             case kComponentVersionSelect :
  308.             result = CCF(params, DoComponentVersion);
  309.             break;
  310.             
  311.             case kComponentRegisterSelect :
  312.             result = CCF(params, DoComponentRegister);
  313.             break;
  314.             
  315.             default :
  316.             result = noErr;
  317.             break;
  318.         }
  319.     }
  320.     else /* Selectors >= 0 for CMM functions */ 
  321.     {
  322.         switch (message)
  323.         {
  324.              case kCMMInit :
  325.             result = CCFWS(storage, params, DoCMMInit);
  326.             break;
  327.             
  328.              case kNCMMInit :
  329.             result = CCFWS(storage, params, DoNCMMInit);
  330.             break;
  331.             
  332.              case kCMMMatchColors :
  333.             result = CCFWS(storage, params, DoCMMMatchColors);
  334.             break;
  335.             
  336.              case kCMMCheckColors :
  337.             result = CCFWS(storage, params, DoCMMCheckColors);
  338.             break;
  339.             
  340.              case kCMMConcatInit :
  341.             result = CCFWS(storage, params, DoCMMConcatInit);
  342.             break;
  343.             
  344.              case kCMMMatchBitmap :
  345.             result = CCFWS(storage, params, DoCMMMatchBitmap);
  346.             break;
  347.             
  348.              case kCMMCheckBitmap :
  349.             result = CCFWS(storage, params, DoCMMCheckBitmap);
  350.             break;
  351.             
  352.              case kNCMMConcatInit :
  353.             result = CCFWS(storage, params, DoNCMMConcatInit);
  354.             break;
  355.             
  356.             default :
  357.             result = unimpErr;
  358.             break;
  359.         }
  360.     }
  361.     return result ;
  362. }
  363.  
  364.  
  365. static pascal ComponentResult
  366. DoComponentOpen (ComponentInstance self)
  367. {
  368.     ComponentResult        result = noErr;        /* Init for error handling */
  369.     CMMStorageHdl        h;
  370.     
  371.     h = (CMMStorageHdl) NewHandleClear(sizeof(CMMStorageRec));
  372.     if (h == nil)
  373.         result = MemError();
  374.     
  375.     if (result == noErr)
  376.     {
  377.         (**h).ci = self;
  378.         SetComponentInstanceStorage(self, (Handle) h);
  379.     }
  380.     
  381.     return result ;
  382. }
  383.  
  384.  
  385. static pascal ComponentResult
  386. DoComponentClose(CMMStorageHdl storage, ComponentInstance self)
  387. {
  388.     ComponentResult        result = noErr;        /* Init for error handling */
  389.     
  390.     if (storage != nil)
  391.         DisposeHandle((Handle)storage);
  392.     
  393.     return result ;
  394. }
  395.  
  396. static pascal ComponentResult
  397. DoComponentRegister(void)
  398. {
  399.     ComponentResult        result = noErr;        /* Init for error handling */
  400.     long                gestaltCPU;
  401.     long                gestaltSys;
  402.     long                gestaltQD;
  403.     
  404.     // Default -- don't register
  405.     result    = 1;
  406.     
  407.     // We require 68020 processor and 32-Bit Color QD 1.2
  408.     // gestalt68020 is returned for gestaltProcessorType on PowerPC
  409.     if ((Gestalt(gestaltProcessorType, &gestaltCPU) == noErr)    && (gestaltCPU >= gestalt68020)        &&
  410.         (Gestalt(gestaltSystemVersion, &gestaltSys) == noErr)    && (gestaltSys >= 0x0700)            &&
  411.         (Gestalt(gestaltQuickdrawVersion, &gestaltQD) == noErr)    && (gestaltQD >= gestalt32BitQD12))
  412.     {
  413.         // OK to register
  414.         result = 0;
  415.     }
  416.     
  417.     return result ;
  418. }
  419.  
  420.  
  421. #if TARGET_CPU_68K
  422. #pragma code68020 reset
  423. #endif
  424.  
  425.  
  426. static pascal ComponentResult
  427. DoComponentCanDo(short selector)
  428. {
  429.     ComponentResult        result = noErr;        /* Init for error handling */
  430.  
  431.     switch (selector)
  432.     {
  433.         /* Component Manager functions */
  434.         case kComponentOpenSelect:                // -1
  435.         case kComponentCloseSelect:                // -2
  436.         case kComponentCanDoSelect:                // -3
  437.         case kComponentVersionSelect:            // -4
  438.         case kComponentRegisterSelect:            // -5
  439.         result = true;
  440.         break;
  441.         
  442.         /* Supported CMM functions */
  443.         case kCMMInit:                            // 0
  444.         case kNCMMInit:                            // 6
  445.         case kCMMMatchColors:                    // 1
  446.         case kCMMCheckColors:                    // 2
  447.         case kCMMConcatInit:                    // 7
  448.         case kNCMMConcatInit:                    // 18
  449.         result = true;
  450.         break;
  451.  
  452.         case kCMMMatchBitmap:                    // 9
  453.         case kCMMCheckBitmap:                    // 10
  454.         result = true;
  455. //        result = false;
  456.         break;
  457.  
  458.         /* Unsupported CMM functions */
  459.         case kCMMMatchPixMap:                    // 3
  460.         case kCMMCheckPixMap:                    // 4
  461.         case kCMMConcatenateProfiles:            // 5
  462.         case kCMMValidateProfile:                // 8
  463.         case kCMMGetPS2ColorSpace:                // 11
  464.         case kCMMGetPS2ColorRenderingIntent:    // 12
  465.         case kCMMGetPS2ColorRendering:            // 13
  466.         case kCMMFlattenProfile:                // 14
  467.         case kCMMUnflattenProfile:                // 15
  468.         case kCMMNewLinkProfile:                // 16
  469.         case kCMMGetPS2ColorRenderingVMSize:    // 17
  470.         case kNCMMNewLinkProfile:                // 19
  471.         
  472.         result = false;
  473.         break; 
  474.             
  475.         default:
  476.         result = false;
  477.         break; 
  478.     }
  479.  
  480.     return result ;
  481. }
  482.  
  483.  
  484. static pascal ComponentResult
  485. DoComponentVersion(void)
  486. {
  487.     return kCMMVersion;
  488. }
  489.  
  490. #endif
  491.  
  492.  
  493. #if TARGET_OS_WIN32
  494. #pragma mark -
  495. #pragma mark ————— Win entry points —————
  496.  
  497.  
  498.  
  499. CMM_ENTRY CMError
  500. CMMOpen ( UInt32 *cmmRefcon,
  501.           void* hInstance) 
  502. { 
  503. #pragma unused (hInstance)
  504.     *cmmRefcon = (UInt32)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CMMStorageRec));
  505.     if (*cmmRefcon)
  506.         return noErr;
  507.     else
  508.         return memFullErr;
  509. }
  510.  
  511. CMM_ENTRY CMError
  512. CMMClose ( UInt32 *cmmRefcon ) 
  513. {
  514.     if (*cmmRefcon)
  515.         HeapFree(  GetProcessHeap(),  0, (void*)*cmmRefcon);
  516.     return noErr;
  517. }
  518.  
  519.  
  520. CMM_ENTRY CMError  
  521. CMMGetCMMInfo ( UInt32 *cmmRefcon,
  522.                    CMMInfo *info ) 
  523. {
  524. #pragma unused (cmmRefcon)
  525.     CMMInfo theInfo = {
  526.                         sizeof(CMMInfo),
  527.                         FOUR_CHAR_CODE('demo'),
  528.                         FOUR_CHAR_CODE('appl'),
  529.                         kCMMVersion,
  530.                         "Demo CMM",
  531.                         "Demo CMM description string"
  532.                         //,0,"",0,"" 
  533.                         };
  534.     *info = theInfo;
  535.     return noErr;
  536. }
  537.  
  538. CMM_ENTRY CMError  
  539. NCMMInit (UInt32 *cmmRefcon, CMProfileRef srcProfile, CMProfileRef dstProfile)
  540. {
  541.     return DoNCMMInit ((CMMStorageHdl)cmmRefcon, srcProfile, dstProfile);
  542. }
  543.  
  544. CMM_ENTRY CMError  
  545. CMMConcatInit (UInt32 *cmmRefcon, CMConcatProfileSet* profileSet)
  546. {
  547.     return DoCMMConcatInit ((CMMStorageHdl)cmmRefcon, profileSet);
  548. }
  549.  
  550. CMM_ENTRY CMError  
  551. NCMMConcatInit (UInt32 *cmmRefcon, NCMConcatProfileSet* profileSet, CMConcatCallBackUPP proc, void* refCon)
  552. {
  553.     return DoNCMMConcatInit ((CMMStorageHdl)cmmRefcon, profileSet, proc, refCon);
  554. }
  555.  
  556. CMM_ENTRY CMError  
  557. CMMMatchColors (UInt32 *cmmRefcon, CMColor *colorBuf, UInt32 count)
  558. {
  559.     return DoCMMMatchColors ((CMMStorageHdl)cmmRefcon, colorBuf, count);
  560. }
  561.                             
  562. CMM_ENTRY CMError  
  563. CMMCheckColors (UInt32 *cmmRefcon, CMColor *colorBuf, UInt32 count, UInt32* gamutResult)
  564. {
  565.     return DoCMMCheckColors ((CMMStorageHdl)cmmRefcon, colorBuf, count, gamutResult);
  566. }
  567.  
  568. CMM_ENTRY CMError  
  569. CMMMatchBitmap (UInt32 *cmmRefcon, CMBitmap * srcMap,
  570.                  CMBitmapCallBackUPP progressProc, void * refCon,
  571.                  CMBitmap* dstMap)
  572. {
  573.     return DoCMMMatchBitmap ((CMMStorageHdl)cmmRefcon, srcMap, progressProc, refCon, dstMap);
  574. }
  575.  
  576. CMM_ENTRY CMError  
  577. CMMCheckBitmap (UInt32 *cmmRefcon,  const CMBitmap * srcMap,
  578.                  CMBitmapCallBackUPP progressProc, void * refCon,
  579.                  CMBitmap* chkMap)
  580. {
  581.     return DoCMMCheckBitmap ((CMMStorageHdl)cmmRefcon,  srcMap, progressProc, refCon, chkMap);
  582. }
  583.  
  584. #endif
  585.  
  586.  
  587. #pragma mark -
  588. #pragma mark ————— implimentations —————
  589.  
  590.  
  591. static pascal CMError
  592. DoCMMInit(CMMStorageHdl storage, CMProfileHandle srcProfile, CMProfileHandle dstProfile)
  593. {    
  594.     // Check params
  595.     if ((srcProfile == nil) || (dstProfile == nil))
  596.         return paramErr;
  597.     
  598.     (**storage).srcSpace = (**srcProfile).header.dataType;
  599.     (**storage).srcClass = (**srcProfile).header.deviceType;
  600.     
  601.     (**storage).dstSpace = (**dstProfile).header.dataType;
  602.     (**storage).dstClass = (**dstProfile).header.deviceType;
  603.  
  604.     return CheckStorage(storage);
  605. }
  606.                                 
  607.  
  608. typedef struct CMConcatProfileSet2 {
  609.     unsigned short         keyIndex;        /* Zero-based */
  610.     unsigned short         count;            /* Min 1, Max 2 */
  611.     CMProfileRef         profileSet[2];    /* Fixed. Source and Dest */
  612. } CMConcatProfileSet2;
  613.  
  614. static pascal CMError
  615. DoNCMMInit (CMMStorageHdl storage, CMProfileRef srcProfile, CMProfileRef dstProfile)
  616. {
  617.     CMConcatProfileSet2        set;
  618.     
  619.     set.keyIndex = 0;
  620.     set.count = 2;
  621.     set.profileSet[0] = srcProfile;
  622.     set.profileSet[1] = dstProfile;
  623.         
  624.     return DoCMMConcatInit(storage, (CMConcatProfileSet*)&set);
  625. }
  626.  
  627.  
  628. static pascal CMError
  629. DoCMMConcatInit (CMMStorageHdl storage, CMConcatProfileSet* profileSet)
  630. {
  631.     ComponentResult            result = noErr;        /* Init for error handling */
  632.     CMAppleProfileHeader    srcHdr;
  633.     CMAppleProfileHeader    dstHdr;
  634.     CMProfileRef            srcProfile;
  635.     CMProfileRef            dstProfile;
  636.     
  637.     // Check params
  638.     if (profileSet==nil)
  639.         return paramErr;
  640.     
  641.     srcProfile = profileSet->profileSet[0];
  642.     dstProfile = profileSet->profileSet[profileSet->count-1];
  643.     if ((srcProfile == nil) || (dstProfile == nil))
  644.         return paramErr;
  645.     
  646.     if (result == noErr)
  647.         result = CMGetProfileHeader(srcProfile, &srcHdr);
  648.     
  649.     if (result == noErr)
  650.         result = CMGetProfileHeader(dstProfile, &dstHdr);
  651.     
  652.     if (result == noErr)
  653.     {
  654.         (**storage).srcSpace = srcHdr.cm2.dataColorSpace;
  655.         (**storage).srcClass = srcHdr.cm2.profileClass;
  656.         
  657.         (**storage).dstSpace = dstHdr.cm2.dataColorSpace;
  658.         (**storage).dstClass = dstHdr.cm2.profileClass;
  659.         
  660.         result = CheckStorage(storage);
  661.     }
  662.         
  663.     return result ;
  664. }
  665.  
  666.  
  667.  
  668. static pascal CMError
  669. DoNCMMConcatInit (CMMStorageHdl storage, NCMConcatProfileSet* profileSet, CMConcatCallBackUPP, void*)
  670. {
  671.     ComponentResult            result = noErr;        /* Init for error handling */
  672.     CMAppleProfileHeader    srcHdr;
  673.     CMAppleProfileHeader    dstHdr;
  674.     CMProfileRef            srcProfile;
  675.     CMProfileRef            dstProfile;
  676.     UInt32                     srcTransform;
  677.     UInt32                     dstTransform;
  678.     
  679.     // Check params
  680.     if (profileSet==nil)
  681.         return paramErr;
  682.     
  683.     srcProfile = profileSet->profileSpecs[0].profile;
  684.     dstProfile = profileSet->profileSpecs[profileSet->profileCount-1].profile;
  685.     if ((srcProfile == nil) || (dstProfile == nil))
  686.         return paramErr;
  687.     
  688.     srcTransform = profileSet->profileSpecs[0].transformTag;
  689.     dstTransform = profileSet->profileSpecs[profileSet->profileCount-1].transformTag;
  690.     
  691.     if (result == noErr)
  692.         result = CMGetProfileHeader(srcProfile, &srcHdr);
  693.     
  694.     if (result == noErr)
  695.         result = CMGetProfileHeader(dstProfile, &dstHdr);
  696.     
  697.     if (result == noErr)
  698.     {
  699.         (**storage).srcSpace = srcHdr.cm2.dataColorSpace;
  700.         (**storage).srcClass = srcHdr.cm2.profileClass;
  701.         
  702.         (**storage).dstSpace = dstHdr.cm2.dataColorSpace;
  703.         (**storage).dstClass = dstHdr.cm2.profileClass;
  704.         
  705.         result = CheckStorage(storage);
  706.     }
  707.         
  708.     return result ;
  709. }
  710.  
  711.  
  712.  
  713. static pascal CMError
  714. DoCMMMatchColors (CMMStorageHdl storage, CMColor *colorBuf, UInt32 count)
  715. {
  716.     CMMMatchRec            matchInfo;
  717.     
  718.     matchInfo.storage        = storage;
  719.     matchInfo.height        = count;
  720.     matchInfo.width            = 1;
  721.     matchInfo.srcSpace        = (**storage).srcSpace;
  722.     matchInfo.srcBuf[0]        = ((UInt8*)colorBuf) + 0;
  723.     matchInfo.srcBuf[1]        = ((UInt8*)colorBuf) + 2;
  724.     matchInfo.srcBuf[2]        = ((UInt8*)colorBuf) + 4;
  725.     matchInfo.srcBuf[3]        = ((UInt8*)colorBuf) + 6;
  726.     matchInfo.srcChanBits    = 16;
  727.     matchInfo.srcRowBytes    = sizeof(CMColor);
  728.     matchInfo.srcColBytes    = sizeof(CMColor);
  729.     matchInfo.srcSwap        = false;
  730.     
  731.     matchInfo.dstSpace        = (**storage).dstSpace;
  732.     matchInfo.dstBuf[0]        = ((UInt8*)colorBuf) + 0;
  733.     matchInfo.dstBuf[1]        = ((UInt8*)colorBuf) + 2;
  734.     matchInfo.dstBuf[2]        = ((UInt8*)colorBuf) + 4;
  735.     matchInfo.dstBuf[3]        = ((UInt8*)colorBuf) + 6;
  736.     matchInfo.dstChanBits    = 16;
  737.     matchInfo.dstRowBytes    = sizeof(CMColor);
  738.     matchInfo.dstColBytes    = sizeof(CMColor);
  739.     matchInfo.dstSwap        = false;
  740.     
  741.     MatchAll(&matchInfo);
  742.     
  743.     return noErr;
  744. }
  745.                                 
  746.  
  747. static pascal CMError
  748. DoCMMCheckColors (CMMStorageHdl storage,  CMColor *colorBuf, UInt32 count, UInt32* gamutResult)
  749. {
  750. #pragma unused (storage, colorBuf)
  751.     
  752.     UInt32        longCount;
  753.     
  754.     /* Everything is in gamut. This is just sample code. */
  755.     
  756.     longCount = (count + 31) / 32;
  757.     
  758.     while (longCount--)
  759.         *gamutResult++ = 0xFFFFFFFF;
  760.     
  761.     return noErr;
  762. }
  763.  
  764.  
  765. static pascal CMError
  766. DoCMMMatchBitmap (CMMStorageHdl storage,  const CMBitmap * srcMap,
  767.                  CMBitmapCallBackUPP progressProc, void * refCon,
  768.                  CMBitmap* dstMap)
  769. {
  770. #pragma unused (progressProc, refCon)
  771.     
  772.     CMMMatchRec            matchInfo;
  773.     
  774.     // Check params
  775.     if (srcMap==nil || dstMap==nil)
  776.         return paramErr;
  777.     
  778.     matchInfo.storage        = storage;
  779.     matchInfo.height        = srcMap->height;
  780.     matchInfo.width            = srcMap->width;
  781.     matchInfo.srcRowBytes    = srcMap->rowBytes;
  782.     matchInfo.dstRowBytes    = dstMap->rowBytes;
  783.     
  784.     switch (srcMap->space)
  785.     {
  786.         case cmGray8Space:
  787.         matchInfo.srcSpace        = cmGrayData;
  788.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  789.         matchInfo.srcBuf[1]        = nil;
  790.         matchInfo.srcBuf[2]        = nil;
  791.         matchInfo.srcBuf[3]        = nil;
  792.         matchInfo.srcChanBits    = 8;
  793.         matchInfo.srcColBytes    = 1;
  794.         break;
  795.         
  796.         case cmGray16Space:
  797.         case cmGray16LSpace:
  798.         matchInfo.srcSpace        = cmGrayData;
  799.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  800.         matchInfo.srcBuf[1]        = nil;
  801.         matchInfo.srcBuf[2]        = nil;
  802.         matchInfo.srcBuf[3]        = nil;
  803.         matchInfo.srcChanBits    = 16;
  804.         matchInfo.srcColBytes    = 2;
  805.         break;
  806.     
  807.         case cmRGB24Space:
  808.         matchInfo.srcSpace        = cmRGBData;
  809.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  810.         matchInfo.srcBuf[1]        = (UInt8*)srcMap->image + 1;
  811.         matchInfo.srcBuf[2]        = (UInt8*)srcMap->image + 2;
  812.         matchInfo.srcBuf[3]        = nil;
  813.         matchInfo.srcChanBits    = 8;
  814.         matchInfo.srcColBytes    = 3;
  815.         break;
  816.         
  817.         case cmRGB32Space:
  818.         matchInfo.srcSpace        = cmRGBData;
  819.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 1;
  820.         matchInfo.srcBuf[1]        = (UInt8*)srcMap->image + 2;
  821.         matchInfo.srcBuf[2]        = (UInt8*)srcMap->image + 3;
  822.         matchInfo.srcBuf[3]        = nil;
  823.         matchInfo.srcChanBits    = 8;
  824.         matchInfo.srcColBytes    = 4;
  825.         break;
  826.         
  827.         case cmRGB48Space:
  828.         case cmRGB48LSpace:
  829.         matchInfo.srcSpace        = cmRGBData;
  830.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  831.         matchInfo.srcBuf[1]        = (UInt8*)srcMap->image + 2;
  832.         matchInfo.srcBuf[2]        = (UInt8*)srcMap->image + 4;
  833.         matchInfo.srcBuf[3]        = nil;
  834.         matchInfo.srcChanBits    = 16;
  835.         matchInfo.srcColBytes    = 6;
  836.         break;
  837.         
  838.         case cmCMYK32Space:
  839.         matchInfo.srcSpace        = cmCMYKData;
  840.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  841.         matchInfo.srcBuf[1]        = (UInt8*)srcMap->image + 1;
  842.         matchInfo.srcBuf[2]        = (UInt8*)srcMap->image + 2;
  843.         matchInfo.srcBuf[3]        = (UInt8*)srcMap->image + 3;
  844.         matchInfo.srcChanBits    = 8;
  845.         matchInfo.srcColBytes    = 4;
  846.         break;
  847.         
  848.         case cmCMYK64Space:
  849.         case cmCMYK64LSpace:
  850.         matchInfo.srcSpace        = cmCMYKData;
  851.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  852.         matchInfo.srcBuf[1]        = (UInt8*)srcMap->image + 2;
  853.         matchInfo.srcBuf[2]        = (UInt8*)srcMap->image + 4;
  854.         matchInfo.srcBuf[3]        = (UInt8*)srcMap->image + 6;
  855.         matchInfo.srcChanBits    = 16;
  856.         matchInfo.srcColBytes    = 8;
  857.         break;
  858.         
  859.         case cmLAB24Space:
  860.         matchInfo.srcSpace        = cmLabData;
  861.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  862.         matchInfo.srcBuf[1]        = (UInt8*)srcMap->image + 1;
  863.         matchInfo.srcBuf[2]        = (UInt8*)srcMap->image + 2;
  864.         matchInfo.srcBuf[3]        = nil;
  865.         matchInfo.srcChanBits    = 8;
  866.         matchInfo.srcColBytes    = 3;
  867.         break;
  868.         
  869.         case cmLAB48Space:
  870.         case cmLAB48LSpace:
  871.         matchInfo.srcSpace        = cmLabData;
  872.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  873.         matchInfo.srcBuf[1]        = (UInt8*)srcMap->image + 2;
  874.         matchInfo.srcBuf[2]        = (UInt8*)srcMap->image + 4;
  875.         matchInfo.srcBuf[3]        = nil;
  876.         matchInfo.srcChanBits    = 16;
  877.         matchInfo.srcColBytes    = 6;
  878.         break;
  879.         
  880.         case cmXYZ24Space:
  881.         matchInfo.srcSpace        = cmXYZData;
  882.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  883.         matchInfo.srcBuf[1]        = (UInt8*)srcMap->image + 1;
  884.         matchInfo.srcBuf[2]        = (UInt8*)srcMap->image + 2;
  885.         matchInfo.srcBuf[3]        = nil;
  886.         matchInfo.srcChanBits    = 8;
  887.         matchInfo.srcColBytes    = 3;
  888.         break;
  889.         
  890.         case cmXYZ48Space:
  891.         case cmXYZ48LSpace:
  892.         matchInfo.srcSpace        = cmXYZData;
  893.         matchInfo.srcBuf[0]        = (UInt8*)srcMap->image + 0;
  894.         matchInfo.srcBuf[1]        = (UInt8*)srcMap->image + 2;
  895.         matchInfo.srcBuf[2]        = (UInt8*)srcMap->image + 4;
  896.         matchInfo.srcBuf[3]        = nil;
  897.         matchInfo.srcChanBits    = 16;
  898.         matchInfo.srcColBytes    = 6;
  899.         break;
  900.         
  901.         default:
  902.         return cmInvalidSrcMap;
  903.         break;
  904.     }
  905.     
  906.     #if TARGET_RT_LITTLE_ENDIAN
  907.         matchInfo.srcSwap = ((srcMap->space & cmLittleEndianPacking) == 0);
  908.     #else
  909.         matchInfo.srcSwap = ((srcMap->space & cmLittleEndianPacking) == cmLittleEndianPacking);
  910.     #endif
  911.     
  912.     
  913.     switch (dstMap->space)
  914.     {
  915.         case cmGray8Space:
  916.         matchInfo.dstSpace        = cmGrayData;
  917.         matchInfo.dstBuf[0]        = (UInt8*)srcMap->image + 0;
  918.         matchInfo.dstBuf[1]        = nil;
  919.         matchInfo.dstBuf[2]        = nil;
  920.         matchInfo.dstBuf[3]        = nil;
  921.         matchInfo.dstChanBits    = 8;
  922.         matchInfo.dstColBytes    = 1;
  923.         break;
  924.         
  925.         case cmGray16Space:
  926.         case cmGray16LSpace:
  927.         matchInfo.dstSpace        = cmGrayData;
  928.         matchInfo.dstBuf[0]        = (UInt8*)srcMap->image + 0;
  929.         matchInfo.dstBuf[1]        = nil;
  930.         matchInfo.dstBuf[2]        = nil;
  931.         matchInfo.dstBuf[3]        = nil;
  932.         matchInfo.dstChanBits    = 16;
  933.         matchInfo.dstColBytes    = 2;
  934.         break;
  935.     
  936.         case cmRGB24Space:
  937.         matchInfo.dstSpace        = cmRGBData;
  938.         matchInfo.dstBuf[0]        = (UInt8*)dstMap->image + 0;
  939.         matchInfo.dstBuf[1]        = (UInt8*)dstMap->image + 1;
  940.         matchInfo.dstBuf[2]        = (UInt8*)dstMap->image + 2;
  941.         matchInfo.dstBuf[3]        = nil;
  942.         matchInfo.dstChanBits    = 8;
  943.         matchInfo.dstColBytes    = 3;
  944.         break;
  945.         
  946.         case cmRGB32Space:
  947.         matchInfo.dstSpace        = cmRGBData;
  948.         matchInfo.dstBuf[0]        = (UInt8*)dstMap->image + 1;
  949.         matchInfo.dstBuf[1]        = (UInt8*)dstMap->image + 2;
  950.         matchInfo.dstBuf[2]        = (UInt8*)dstMap->image + 3;
  951.         matchInfo.dstBuf[3]        = nil;
  952.         matchInfo.dstChanBits    = 8;
  953.         matchInfo.dstColBytes    = 4;
  954.         break;
  955.         
  956.         case cmRGB48Space:
  957.         case cmRGB48LSpace:
  958.         matchInfo.dstSpace        = cmRGBData;
  959.         matchInfo.dstBuf[0]        = (UInt8*)dstMap->image + 0;
  960.         matchInfo.dstBuf[1]        = (UInt8*)dstMap->image + 2;
  961.         matchInfo.dstBuf[2]        = (UInt8*)dstMap->image + 4;
  962.         matchInfo.dstBuf[3]        = nil;
  963.         matchInfo.dstChanBits    = 16;
  964.         matchInfo.dstColBytes    = 6;
  965.         break;
  966.         
  967.         case cmCMYK32Space:
  968.         matchInfo.dstSpace        = cmCMYKData;
  969.         matchInfo.dstBuf[0]        = (UInt8*)dstMap->image + 0;
  970.         matchInfo.dstBuf[1]        = (UInt8*)dstMap->image + 1;
  971.         matchInfo.dstBuf[2]        = (UInt8*)dstMap->image + 2;
  972.         matchInfo.dstBuf[3]        = (UInt8*)dstMap->image + 3;
  973.         matchInfo.dstChanBits    = 8;
  974.         matchInfo.dstColBytes    = 4;
  975.         break;
  976.         
  977.         case cmCMYK64Space:
  978.         case cmCMYK64LSpace:
  979.         matchInfo.dstSpace        = cmCMYKData;
  980.         matchInfo.dstBuf[0]        = (UInt8*)dstMap->image + 0;
  981.         matchInfo.dstBuf[1]        = (UInt8*)dstMap->image + 2;
  982.         matchInfo.dstBuf[2]        = (UInt8*)dstMap->image + 4;
  983.         matchInfo.dstBuf[3]        = (UInt8*)dstMap->image + 6;
  984.         matchInfo.dstChanBits    = 16;
  985.         matchInfo.dstColBytes    = 8;
  986.         break;
  987.         
  988.         case cmLAB24Space:
  989.         matchInfo.dstSpace        = cmLabData;
  990.         matchInfo.dstBuf[0]        = (UInt8*)dstMap->image + 0;
  991.         matchInfo.dstBuf[1]        = (UInt8*)dstMap->image + 1;
  992.         matchInfo.dstBuf[2]        = (UInt8*)dstMap->image + 2;
  993.         matchInfo.dstBuf[3]        = nil;
  994.         matchInfo.dstChanBits    = 8;
  995.         matchInfo.dstColBytes    = 3;
  996.         break;
  997.         
  998.         case cmLAB48Space:
  999.         case cmLAB48LSpace:
  1000.         matchInfo.dstSpace        = cmLabData;
  1001.         matchInfo.dstBuf[0]        = (UInt8*)dstMap->image + 0;
  1002.         matchInfo.dstBuf[1]        = (UInt8*)dstMap->image + 2;
  1003.         matchInfo.dstBuf[2]        = (UInt8*)dstMap->image + 4;
  1004.         matchInfo.dstBuf[3]        = nil;
  1005.         matchInfo.dstChanBits    = 16;
  1006.         matchInfo.dstColBytes    = 6;
  1007.         break;
  1008.         
  1009.         case cmXYZ24Space:
  1010.         matchInfo.dstSpace        = cmXYZData;
  1011.         matchInfo.dstBuf[0]        = (UInt8*)dstMap->image + 0;
  1012.         matchInfo.dstBuf[1]        = (UInt8*)dstMap->image + 1;
  1013.         matchInfo.dstBuf[2]        = (UInt8*)dstMap->image + 2;
  1014.         matchInfo.dstBuf[3]        = nil;
  1015.         matchInfo.dstChanBits    = 8;
  1016.         matchInfo.dstColBytes    = 3;
  1017.         break;
  1018.         
  1019.         case cmXYZ48Space:
  1020.         case cmXYZ48LSpace:
  1021.         matchInfo.dstSpace        = cmXYZData;
  1022.         matchInfo.dstBuf[0]        = (UInt8*)dstMap->image + 0;
  1023.         matchInfo.dstBuf[1]        = (UInt8*)dstMap->image + 2;
  1024.         matchInfo.dstBuf[2]        = (UInt8*)dstMap->image + 4;
  1025.         matchInfo.dstBuf[3]        = nil;
  1026.         matchInfo.dstChanBits    = 16;
  1027.         matchInfo.dstColBytes    = 6;
  1028.         break;
  1029.         
  1030.         default:
  1031.         return cmInvalidSrcMap;
  1032.         break;
  1033.     }
  1034.     
  1035.     #if TARGET_RT_LITTLE_ENDIAN
  1036.         matchInfo.dstSwap = ((dstMap->space & cmLittleEndianPacking) == 0);
  1037.     #else
  1038.         matchInfo.dstSwap = ((dstMap->space & cmLittleEndianPacking) == cmLittleEndianPacking);
  1039.     #endif
  1040.     
  1041.     
  1042.     if ((**storage).srcSpace != matchInfo.srcSpace)
  1043.         return cmInvalidSrcMap;
  1044.     
  1045.     
  1046.     if ((**storage).dstSpace != matchInfo.dstSpace)
  1047.         return cmInvalidDstMap;
  1048.     
  1049.     MatchAll(&matchInfo);
  1050.     
  1051.     return noErr;
  1052. }
  1053.  
  1054.  
  1055. static pascal CMError
  1056. DoCMMCheckBitmap (CMMStorageHdl storage,  const CMBitmap * srcMap,
  1057.                  CMBitmapCallBackUPP progressProc, void * refCon,
  1058.                  CMBitmap* chkMap)
  1059. {
  1060. #pragma unused (storage, srcMap, progressProc, refCon, chkMap)
  1061.     return paramErr;
  1062. }
  1063.  
  1064.  
  1065. #pragma mark -
  1066. #pragma mark ————— utilities —————
  1067.  
  1068. static CMError
  1069. CheckStorage (CMMStorageHdl storage)
  1070. {
  1071.     OSType            srcSpace = (**storage).srcSpace;
  1072.     OSType            dstSpace = (**storage).dstSpace;
  1073.     
  1074.     (**storage).proc = nil;
  1075.     
  1076.     if (srcSpace == dstSpace)
  1077.         return noErr;
  1078.     
  1079.     if      (srcSpace==cmRGBData  && dstSpace==cmCMYKData)        (**storage).proc = &MatchOne_RGB_CMYK;
  1080.     else if (srcSpace==cmRGBData  && dstSpace==cmXYZData)        (**storage).proc = &MatchOne_RGB_XYZ;
  1081.     else if (srcSpace==cmRGBData  && dstSpace==cmLabData)        (**storage).proc = &MatchOne_RGB_LAB;
  1082.     else if (srcSpace==cmRGBData  && dstSpace==cmGrayData)        (**storage).proc = &MatchOne_RGB_Gray;
  1083.     else if (srcSpace==cmCMYKData && dstSpace==cmRGBData)        (**storage).proc = &MatchOne_CMYK_RGB;
  1084.     else if (srcSpace==cmCMYKData && dstSpace==cmLabData)        (**storage).proc = &MatchOne_CMYK_LAB;
  1085.     else if (srcSpace==cmCMYKData && dstSpace==cmXYZData)        (**storage).proc = &MatchOne_CMYK_XYZ;
  1086.     else if (srcSpace==cmCMYKData && dstSpace==cmGrayData)        (**storage).proc = &MatchOne_CMYK_Gray;
  1087.     else if (srcSpace==cmXYZData  && dstSpace==cmRGBData)        (**storage).proc = &MatchOne_XYZ_RGB;
  1088.     else if (srcSpace==cmXYZData  && dstSpace==cmLabData)        (**storage).proc = &MatchOne_XYZ_LAB;
  1089.     else if (srcSpace==cmXYZData  && dstSpace==cmCMYKData)        (**storage).proc = &MatchOne_XYZ_CMYK;
  1090.     else if (srcSpace==cmXYZData  && dstSpace==cmGrayData)        (**storage).proc = &MatchOne_XYZ_Gray;
  1091.     else if (srcSpace==cmLabData  && dstSpace==cmRGBData)        (**storage).proc = &MatchOne_LAB_RGB;
  1092.     else if (srcSpace==cmLabData  && dstSpace==cmXYZData)        (**storage).proc = &MatchOne_LAB_XYZ;
  1093.     else if (srcSpace==cmLabData  && dstSpace==cmCMYKData)        (**storage).proc = &MatchOne_LAB_CMYK;
  1094.     else if (srcSpace==cmLabData  && dstSpace==cmGrayData)        (**storage).proc = &MatchOne_LAB_Gray;
  1095.     else if (srcSpace==cmGrayData && dstSpace==cmRGBData)        (**storage).proc = &MatchOne_Gray_RGB;
  1096.     else if (srcSpace==cmGrayData && dstSpace==cmCMYKData)        (**storage).proc = &MatchOne_Gray_CMYK;
  1097.     else if (srcSpace==cmGrayData && dstSpace==cmXYZData)        (**storage).proc = &MatchOne_Gray_XYZ;
  1098.     else if (srcSpace==cmGrayData && dstSpace==cmLabData)        (**storage).proc = &MatchOne_Gray_LAB;
  1099.     else
  1100.         return cmInvalidProfile;
  1101.     
  1102.     return noErr;
  1103. }
  1104.  
  1105.  
  1106. static void
  1107. DebugColor4( UInt16* color)
  1108. {
  1109. #if TARGET_OS_MAC
  1110.     Str255            s = "\p 0xXXXX, 0xXXXX, 0xXXXX, 0xXXXX";
  1111.     UInt8*            c = &(s[4]);
  1112. #else if TARGET_OS_WIN32
  1113.     char            s[] = " 0xXXXX, 0xXXXX, 0xXXXX, 0xXXXX";
  1114.     char*            c = &(s[3]);
  1115. #endif
  1116.     int                i;
  1117.     int                v;
  1118.     
  1119.     for (i=0; i<4; i++)
  1120.     {
  1121.         v = (((*color)>>12) & 0x000F);    *c++ = (v<10) ? (v+'0') : (v+'A'-10);
  1122.         v = (((*color)>>8) & 0x000F);    *c++ = (v<10) ? (v+'0') : (v+'A'-10);
  1123.         v = (((*color)>>4) & 0x000F);    *c++ = (v<10) ? (v+'0') : (v+'A'-10);
  1124.         v = (((*color)) & 0x000F);        *c++ = (v<10) ? (v+'0') : (v+'A'-10);
  1125.         c += 4;
  1126.         color++;
  1127.     }
  1128.     
  1129. #if TARGET_OS_MAC
  1130.     DebugStr(s);
  1131. #else if TARGET_OS_WIN32
  1132. #endif
  1133. }
  1134.  
  1135.  
  1136. //
  1137. // Simple conversion of a bunch or colors. This is just sample code.
  1138. //
  1139. static void
  1140. MatchAll (CMMMatchPtr pMatchInfo)
  1141. {
  1142.     UInt32                r,c;
  1143.     UInt16                chan[4];
  1144.     UInt8**                sBuf;
  1145.     UInt8**                dBuf;
  1146.     
  1147.     sBuf = pMatchInfo->srcBuf;
  1148.     dBuf = pMatchInfo->dstBuf;
  1149.     
  1150.     for (r=0; r < pMatchInfo->height; r++)
  1151.     {
  1152.         for (c=0; c < pMatchInfo->width; c++)
  1153.         {
  1154.             // read color in from source buffer
  1155.             if (pMatchInfo->srcChanBits==16)
  1156.             {
  1157.                 if (sBuf[0]) chan[0] = *(UInt16*)(sBuf[0] + (r * pMatchInfo->srcRowBytes) + (c * pMatchInfo->srcColBytes));
  1158.                 if (sBuf[1]) chan[1] = *(UInt16*)(sBuf[1] + (r * pMatchInfo->srcRowBytes) + (c * pMatchInfo->srcColBytes));
  1159.                 if (sBuf[2]) chan[2] = *(UInt16*)(sBuf[2] + (r * pMatchInfo->srcRowBytes) + (c * pMatchInfo->srcColBytes));
  1160.                 if (sBuf[3]) chan[3] = *(UInt16*)(sBuf[3] + (r * pMatchInfo->srcRowBytes) + (c * pMatchInfo->srcColBytes));
  1161.             }
  1162.             else
  1163.             {
  1164.                 if (sBuf[0]) chan[0] = *(UInt8*)(sBuf[0] + (r * pMatchInfo->srcRowBytes) + (c * pMatchInfo->srcColBytes));
  1165.                 if (sBuf[1]) chan[1] = *(UInt8*)(sBuf[1] + (r * pMatchInfo->srcRowBytes) + (c * pMatchInfo->srcColBytes));
  1166.                 if (sBuf[2]) chan[2] = *(UInt8*)(sBuf[2] + (r * pMatchInfo->srcRowBytes) + (c * pMatchInfo->srcColBytes));
  1167.                 if (sBuf[3]) chan[3] = *(UInt8*)(sBuf[3] + (r * pMatchInfo->srcRowBytes) + (c * pMatchInfo->srcColBytes));
  1168.                 chan[0] = (chan[0] << 8) | chan[0];
  1169.                 chan[1] = (chan[1] << 8) | chan[1];
  1170.                 chan[2] = (chan[2] << 8) | chan[2];
  1171.                 chan[3] = (chan[3] << 8) | chan[3];
  1172.             }
  1173.             
  1174.             if (pMatchInfo->srcSwap)
  1175.             {
  1176.                 chan[0] = Endian16_Swap(chan[0]);
  1177.                 chan[1] = Endian16_Swap(chan[1]);
  1178.                 chan[2] = Endian16_Swap(chan[2]);
  1179.                 chan[3] = Endian16_Swap(chan[3]);
  1180.             }
  1181.             
  1182.             // DebugColor4(chan);
  1183.             
  1184.             // Match the color
  1185.             if ((**(pMatchInfo->storage)).proc)
  1186.                 ((**(pMatchInfo->storage)).proc)(chan);
  1187.             
  1188.             // DebugColor4(chan);
  1189.             
  1190.             if (pMatchInfo->dstSwap)
  1191.             {
  1192.                 chan[0] = Endian16_Swap(chan[0]);
  1193.                 chan[1] = Endian16_Swap(chan[1]);
  1194.                 chan[2] = Endian16_Swap(chan[2]);
  1195.                 chan[3] = Endian16_Swap(chan[3]);
  1196.             }
  1197.             
  1198.             // Write color to destination buffer
  1199.             if (pMatchInfo->dstChanBits==16)
  1200.             {
  1201.                 if (dBuf[0]) *(UInt16*)(dBuf[0] + (r * pMatchInfo->dstRowBytes) + (c * pMatchInfo->dstColBytes)) = chan[0];
  1202.                 if (dBuf[1]) *(UInt16*)(dBuf[1] + (r * pMatchInfo->dstRowBytes) + (c * pMatchInfo->dstColBytes)) = chan[1];
  1203.                 if (dBuf[2]) *(UInt16*)(dBuf[2] + (r * pMatchInfo->dstRowBytes) + (c * pMatchInfo->dstColBytes)) = chan[2];
  1204.                 if (dBuf[3]) *(UInt16*)(dBuf[3] + (r * pMatchInfo->dstRowBytes) + (c * pMatchInfo->dstColBytes)) = chan[3];
  1205.             }
  1206.             else
  1207.             {
  1208.                 if (dBuf[0]) *(UInt8*)(dBuf[0] + (r * pMatchInfo->dstRowBytes) + (c * pMatchInfo->dstColBytes)) = chan[0] >> 8;
  1209.                 if (dBuf[1]) *(UInt8*)(dBuf[1] + (r * pMatchInfo->dstRowBytes) + (c * pMatchInfo->dstColBytes)) = chan[1] >> 8;
  1210.                 if (dBuf[2]) *(UInt8*)(dBuf[2] + (r * pMatchInfo->dstRowBytes) + (c * pMatchInfo->dstColBytes)) = chan[2] >> 8;
  1211.                 if (dBuf[3]) *(UInt8*)(dBuf[3] + (r * pMatchInfo->dstRowBytes) + (c * pMatchInfo->dstColBytes)) = chan[3] >> 8;
  1212.             }
  1213.         }
  1214.     }
  1215. }
  1216.  
  1217.  
  1218. //
  1219. // Simple conversions of one color with 16 bits-per-channel 
  1220. //
  1221. static void
  1222. MatchOne_RGB_CMYK (UInt16* chan)
  1223. {
  1224.     chan[0] = 0xFFFF - chan[0];
  1225.     chan[1] = 0xFFFF - chan[1];
  1226.     chan[2] = 0xFFFF - chan[2];
  1227.     chan[3] = (chan[0] < chan[1]) ?
  1228.                 ( (chan[0] < chan[2]) ? (chan[0]) : (chan[2]) ) :
  1229.                 ( (chan[1] < chan[2]) ? (chan[1]) : (chan[2]) );
  1230.     chan[0] -= chan[3];
  1231.     chan[1] -= chan[3];
  1232.     chan[2] -= chan[3];
  1233. }
  1234.  
  1235. static void
  1236. MatchOne_CMYK_RGB (UInt16* chan)
  1237. {
  1238.     chan[0] = 0xFFFF - chan[0];
  1239.     chan[1] = 0xFFFF - chan[1];
  1240.     chan[2] = 0xFFFF - chan[2];
  1241.     chan[0] = (chan[0] > chan[3]) ? (chan[0] - chan[3]) : 0;
  1242.     chan[1] = (chan[1] > chan[3]) ? (chan[1] - chan[3]) : 0;
  1243.     chan[2] = (chan[2] > chan[3]) ? (chan[2] - chan[3]) : 0;
  1244.     chan[3] = 0;
  1245. }
  1246.  
  1247. #define DoubToUInt16(x)        (((x)<=0.0)?(0):(((x)>=1.0)?(65535):((x)*65535.0 + 0.5)))
  1248. #define UInt16ToDoub(x)        ((double)(x)/65535.0)
  1249. #define DoubToFract(x)        (((x)<=0.0)?(0):(((x)>=2.0)?(65535):((x)*32768.0 + 0.5)))
  1250. #define FractToDoub(x)        ((double)(x)/32768.0)
  1251. #define UInt16ToFract(x)    ((x)>>1)
  1252. #define FractToUInt16(x)    ((x)<<1)
  1253.  
  1254. static void
  1255. MatchOne_RGB_XYZ (UInt16* chan)
  1256. {
  1257.     double r,g,b;
  1258.     double X,Y,Z;
  1259.     
  1260.     r = UInt16ToDoub(chan[0]);
  1261.     g = UInt16ToDoub(chan[1]);
  1262.     b = UInt16ToDoub(chan[2]);
  1263.     
  1264.     X = (0.418 * r) + (0.363 * g) + (0.183 * b);
  1265.     Y = (0.213 * r) + (0.715 * g) + (0.072 * b);
  1266.     Z = (0.015 * r) + (0.090 * g) + (0.720 * b);
  1267.      
  1268.     chan[0] = DoubToFract(X);
  1269.     chan[1] = DoubToFract(Y);
  1270.     chan[2] = DoubToFract(Z);
  1271. }
  1272.  
  1273. static void
  1274. MatchOne_XYZ_RGB (UInt16* chan)
  1275. {
  1276.     double r,g,b;
  1277.     double X,Y,Z;
  1278.     
  1279.     X = FractToDoub(chan[0]);
  1280.     Y = FractToDoub(chan[1]);
  1281.     Z = FractToDoub(chan[2]);
  1282.     
  1283.     r = ( 3.202 * X) + (-1.543 * Y) + (-0.660 * Z);
  1284.     g = (-0.959 * X) + ( 1.879 * Y) + ( 0.056 * Z);
  1285.     b = ( 0.053 * X) + (-0.203 * Y) + ( 1.396 * Z);
  1286.     
  1287.     chan[0] = DoubToUInt16(r);
  1288.     chan[1] = DoubToUInt16(g);
  1289.     chan[2] = DoubToUInt16(b);
  1290. }
  1291.  
  1292. static void
  1293. MatchOne_RGB_LAB (UInt16* chan)
  1294. {
  1295.     MatchOne_RGB_XYZ(chan);
  1296.     MatchOne_XYZ_LAB(chan);
  1297. }
  1298.  
  1299. static void
  1300. MatchOne_LAB_RGB (UInt16* chan)
  1301. {
  1302.     MatchOne_LAB_XYZ(chan);
  1303.     MatchOne_XYZ_RGB(chan);
  1304. }
  1305.  
  1306. static void
  1307. MatchOne_XYZ_LAB (UInt16* chan)
  1308. {
  1309. #if TARGET_CPU_68K
  1310.     CMXYZColor white;
  1311.     white.X = 31594;
  1312.     white.Y = 32768;
  1313.     white.Z = 27030;
  1314.     CMConvertXYZToLab( (CMColor*)chan, &white, (CMColor*)chan,1);
  1315. #else
  1316.     double                X, Y, Z;
  1317.     double                L, a, b;
  1318.     double                fx, fy, fz;
  1319.  
  1320.     X = FractToDoub(chan[0]);
  1321.     Y = FractToDoub(chan[1]);
  1322.     Z = FractToDoub(chan[2]);
  1323.  
  1324.     X /= 0.9642;
  1325.     Z /= 0.8249;
  1326.  
  1327.     if (X > 0.008856)
  1328.         fx = pow(X, 0.3333);
  1329.     else
  1330.         fx = 7.787 * X + 16.0 / 116.0;
  1331.     
  1332.     if (Y > 0.008856)
  1333.         fy = pow(Y, 0.3333);
  1334.     else
  1335.         fy = 7.787 * Y + 16.0 / 116.0;
  1336.     
  1337.     if (Z > 0.008856)
  1338.         fz = pow(Z, 0.3333);
  1339.     else
  1340.         fz = 7.787 * Z + 16.0 / 116.0;
  1341.  
  1342.     L = 116.0 * fy - 16;
  1343.     a = 500.0 * (fx - fy);
  1344.     b = 200.0 * (fy - fz);
  1345.     
  1346.     L = L / 100.0;
  1347.     a = (a + 128.0) / 256.0;
  1348.     b = (b + 128.0) / 256.0;
  1349.     
  1350.     chan[0] = DoubToUInt16(L);
  1351.     chan[1] = DoubToUInt16(a);
  1352.     chan[2] = DoubToUInt16(b);
  1353. #endif
  1354. }
  1355.  
  1356. static void
  1357. MatchOne_LAB_XYZ (UInt16* chan)
  1358. {
  1359. #if TARGET_CPU_68K
  1360.     CMXYZColor white;
  1361.     white.X = 31594;
  1362.     white.Y = 32768;
  1363.     white.Z = 27030;
  1364.     CMConvertLabToXYZ( (CMColor*)chan, &white, (CMColor*)chan,1);
  1365. #else
  1366.     double                X, Y, Z;
  1367.     double                L, a, b;
  1368.     double                fx, fy, fz;
  1369.  
  1370.     L = UInt16ToDoub(chan[0]) * 100.0;
  1371.     a = UInt16ToDoub(chan[1]) * 256.0 - 128.0;
  1372.     b = UInt16ToDoub(chan[2]) * 256.0 - 128.0;
  1373.     
  1374.     fy = (L + 16.0) / 116.0;
  1375.     fx = a / 500.0 + fy;
  1376.     fz = fy - b / 200.0;
  1377.     
  1378.     if (fx > 0.20696) 
  1379.         X = pow(fx, 3);
  1380.     else
  1381.         X = (fx - 16.0 / 116.0) / 7.787;
  1382.     
  1383.     if (fy > 0.20696) 
  1384.         Y = pow(fy, 3);
  1385.     else
  1386.         Y = (fy - 16.0 / 116.0) / 7.787;
  1387.     
  1388.     if (fz > 0.20696) 
  1389.         Z = pow(fz, 3);
  1390.     else
  1391.         Z = (fz - 16.0 / 116.0) / 7.787;
  1392.     
  1393.     X *= 0.9642;
  1394.     Z *= 0.8249;
  1395.  
  1396.     chan[0] = DoubToFract(X);
  1397.     chan[1] = DoubToFract(Y);
  1398.     chan[2] = DoubToFract(Z);
  1399. #endif
  1400. }
  1401.  
  1402. static void
  1403. MatchOne_CMYK_LAB (UInt16* chan)
  1404. {
  1405.     MatchOne_CMYK_RGB(chan);
  1406.     MatchOne_RGB_LAB(chan);
  1407. }
  1408.  
  1409. static void
  1410. MatchOne_LAB_CMYK (UInt16* chan)
  1411. {
  1412.     MatchOne_LAB_RGB(chan);
  1413.     MatchOne_RGB_CMYK(chan);
  1414. }
  1415.  
  1416. static void
  1417. MatchOne_CMYK_XYZ (UInt16* chan)
  1418. {
  1419.     MatchOne_CMYK_RGB(chan);
  1420.     MatchOne_RGB_XYZ(chan);
  1421. }
  1422.  
  1423. static void
  1424. MatchOne_XYZ_CMYK (UInt16* chan)
  1425. {
  1426.     MatchOne_XYZ_RGB(chan);
  1427.     MatchOne_RGB_CMYK(chan);
  1428. }
  1429.  
  1430. static void
  1431. MatchOne_RGB_Gray (UInt16* chan)
  1432. {
  1433.     UInt16 alpha;
  1434.     alpha = chan[3]; // preserve alpha
  1435.     MatchOne_RGB_XYZ(chan);
  1436.     MatchOne_XYZ_Gray(chan);
  1437.     chan[1] = alpha; // preserve alpha
  1438. }
  1439.  
  1440. static void
  1441. MatchOne_Gray_RGB (UInt16* chan)
  1442. {
  1443.     chan[3] = chan[1]; // preserve alpha
  1444.     chan[1] = chan[2] = chan[0];
  1445. }
  1446.  
  1447. static void
  1448. MatchOne_LAB_Gray (UInt16* chan)
  1449. {
  1450. #pragma unused (chan)
  1451.     // nothing to do gray = L
  1452. }
  1453.  
  1454. static void
  1455. MatchOne_Gray_LAB (UInt16* chan)
  1456. {
  1457.     chan[1] = chan[2] = 0;
  1458. }
  1459.  
  1460. static void
  1461. MatchOne_CMYK_Gray (UInt16* chan)
  1462. {
  1463.     MatchOne_CMYK_XYZ(chan);
  1464.     MatchOne_XYZ_Gray(chan);
  1465. }
  1466.  
  1467. static void
  1468. MatchOne_Gray_CMYK (UInt16* chan)
  1469. {
  1470.     chan[3] = chan[0]; // K = gray
  1471.     chan[0] = chan[1] = chan[2] = 0; // CMY = 0
  1472. }
  1473.  
  1474. static void
  1475. MatchOne_XYZ_Gray (UInt16* chan)
  1476. {
  1477.     chan[0] = FractToUInt16(chan[1]); // gray = Y
  1478. }
  1479.  
  1480. static void
  1481. MatchOne_Gray_XYZ (UInt16* chan)
  1482. {
  1483.     double X,Y,Z;
  1484.     
  1485.     Y = UInt16ToDoub(chan[0]);
  1486.     X = Y * 0.96417;
  1487.     Z = Y * 0.82489;
  1488.     
  1489.     chan[0] = DoubToFract(X);
  1490.     chan[1] = DoubToFract(Y);
  1491.     chan[2] = DoubToFract(Z);
  1492. }
  1493.  
  1494.